const dayjs = require('dayjs');
/**
 * Notes: 软硬件系统相关函数
 * Ver : CCMiniCloud Framework 2.11.1 ALL RIGHTS RESERVED BY cclinux0730 (wechat)
 * Date: 2022-01-25 29:00:00 
 */


function getAuth(auth, authName, callback) {
	auth = 'scope.' + auth;
	wx.getSetting({
		success: res => {
			console.log(res)
			if (res.authSetting[auth]) {
				console.log('true');
				if (typeof callback === 'function') callback();
			} else if (res.authSetting[auth] === undefined) {
				// 未做任何授权
				wx.showModal({
					title: '提示',
					mask: true,
					content: '您尚未开启' + authName + '的权限，请点击确定去开启权限！',
					success: (res) => {
						if (res.confirm) {
							wx.authorize({
								scope: auth,
								success: (res) => {
									console.log('授权成功', res);
									if (typeof callback === 'function') callback();
								},
								fail: (res) => {
									console.log('您没有授权 fail=', res);
									wx.showToast({
										mask: true,
										title: '您没有授权，无法' + authName,
										icon: 'none'
									});
								}
							});
						} else {
							wx.showToast({
								mask: true,
								title: '您没有授权，无法' + authName,
								icon: 'none'
							});
						}
					}
				});
			} else {
				// 已经禁止
				wx.showModal({
					title: '提示',
					content: '您未开启' + authName + '的权限，请点击确定去开启权限！',
					success: (res) => {
						if (res.confirm) {
							wx.openSetting({
								success: (res) => {
									wx.showToast({
										mask: true,
										icon: 'none',
										title: '正在' + authName,
									});
									if (res.authSetting[auth]) {
										console.log('false success res=', res);
										if (typeof callback === 'function') callback();
									} else {
										wx.showToast({
											mask: true,
											title: '您没有授权，无法' + authName + '！',
											icon: 'none'
										});
									}
								},
								fail: (res) => {
									console.log('false file res=', res);
								}
							});
						} else {
							wx.showToast({
								mask: true,
								title: '您没有授权，无法' + authName,
								icon: 'none'
							});
						}
					}
				});
			}
		}
	});
}

/**
 * 小程序助手
 * 提供小程序基础功能的封装和工具方法
 */

// 构建分享参数
function buildShareOptions(params = {}) {
	const defaultShare = {
		title: 'ABS办公协作', 
		path: '/projects/oa/pages/default/index/default_index',
		imageUrl: ''
	};
	
	return { ...defaultShare, ...params };
}

// 标准化页面路径
function normalizePath(path) {
	if (!path) return '';
	
	// 确保路径以/开头
	if (path.charAt(0) !== '/') {
		path = '/' + path;
	}
	
	return path;
}

// 构建完整URL
function buildFullUrl(path, params = {}) {
	let url = normalizePath(path);
	let queryString = '';
	
	// 构建查询参数
	for (const key in params) {
		if (params[key] !== undefined && params[key] !== null) {
			queryString += `${queryString ? '&' : '?'}${key}=${encodeURIComponent(params[key])}`;
		}
	}
	
	return url + queryString;
}

// 安全导航，处理各种导航异常
function safeNavigate(navigateFunc, url, options = {}) {
	return new Promise((resolve, reject) => {
		navigateFunc({
			url,
			...options,
			success: (res) => {
				if (options.success) options.success(res);
				resolve(res);
			},
			fail: (err) => {
				console.error(`导航失败: ${url}`, err);
				
				// 常见导航错误处理
				if (err.errMsg.includes('tabbar')) {
					// 尝试使用switchTab
					wx.switchTab({
						url,
						success: resolve,
						fail: (switchErr) => {
							if (options.fail) options.fail(switchErr);
							reject(switchErr);
						}
					});
					return;
				}
				
				if (options.fail) options.fail(err);
				reject(err);
			}
		});
	});
}

// 安全的页面跳转
function navigateTo(path, params = {}, options = {}) {
	const url = buildFullUrl(path, params);
	return safeNavigate(wx.navigateTo, url, options);
}

// 重定向
function redirectTo(path, params = {}, options = {}) {
	const url = buildFullUrl(path, params);
	return safeNavigate(wx.redirectTo, url, options);
}

// 回到首页
function backToHome(options = {}) {
	return safeNavigate(wx.switchTab, '/projects/oa/pages/default/index/default_index', options);
}

// 获取当前页面路径
function getCurrentPagePath() {
	const pages = getCurrentPages();
	if (pages.length === 0) return '';
	
	const currentPage = pages[pages.length - 1];
	return currentPage.route || '';
}

// 获取上一级页面
function getPrevPage() {
	const pages = getCurrentPages();
	if (pages.length < 2) return null;
	
	return pages[pages.length - 2];
}

// 获取系统信息
let _systemInfo = null;
/**
 * 获取系统信息
 * @returns {Object} 系统信息对象
 */
function getSystemInfo() {
	if (_systemInfo) return _systemInfo;
	
	try {
		_systemInfo = wx.getSystemInfoSync();
		return _systemInfo;
	} catch (err) {
		console.error('获取系统信息失败', err);
		return {};
	}
}

// 检查是否为iOS系统
function isIOS() {
	const systemInfo = getSystemInfo();
	return systemInfo.platform === 'ios';
}

// 检查是否为Android系统
function isAndroid() {
	const systemInfo = getSystemInfo();
	return systemInfo.platform === 'android';
}

// 检查是否为开发环境
function isDev() {
	// 判断是否为开发环境的逻辑
	return process.env.NODE_ENV === 'development';
}

/**
 * 小程序助手工具
 * 用于提供小程序相关的通用功能
 */

// 多路径引用尝试，优先级从高到低
let errorHelper;
try {
	// 尝试当前目录
	errorHelper = require('./error_helper.js');
} catch (e) {
	try {
		// 尝试PLM项目中的实现
		errorHelper = require('../projects/plm/helpers/error_helper.js');
		console.info('[引用] 使用PLM项目中的error_helper模块');
	} catch (e2) {
		console.warn('[提醒] 未找到error_helper.js模块，使用默认实现');
		// 提供一个默认的错误处理实现
		errorHelper = {
			handleError: function(err) {
				console.error('[错误处理]', err);
				return { 
					success: false, 
					message: typeof err === 'string' ? err : (err.message || '操作失败')
				};
			}
		};
	}
}

const pageHelper = require('./page_helper.js');

/**
 * 获取当前页面信息
 * @returns {Object|null} 当前页面对象
 */
function getCurrentPage() {
	const pages = getCurrentPages();
	if (pages.length === 0) return null;
	
	return pages[pages.length - 1];
}

/**
 * 获取当前环境
 * @returns {String} 环境标识
 */
function getEnvironment() {
	// 判断当前环境
	if (typeof wx !== 'undefined' && wx.getSystemInfoSync) {
		return 'weapp'; // 微信小程序
	} else if (typeof my !== 'undefined' && my.getSystemInfoSync) {
		return 'alipay'; // 支付宝小程序
	} else if (typeof tt !== 'undefined' && tt.getSystemInfoSync) {
		return 'tt'; // 头条小程序
	} else {
		return 'unknown'; // 未知环境
	}
}

/**
 * 检查SDK版本是否满足要求
 * @param {String} requiredVersion 所需的版本号
 * @returns {Boolean} 是否满足版本要求
 */
function checkSDKVersion(requiredVersion) {
	if (!requiredVersion) return true;
	
	try {
		const systemInfo = getSystemInfo();
		const sdkVersion = systemInfo.SDKVersion || '';
		
		// 版本号比较
		const current = sdkVersion.split('.').map(Number);
		const required = requiredVersion.split('.').map(Number);
		
		for (let i = 0; i < Math.max(current.length, required.length); i++) {
			const a = current[i] || 0;
			const b = required[i] || 0;
			if (a > b) return true;
			if (a < b) return false;
		}
		
		return true;
	} catch (e) {
		console.error('检查SDK版本失败', e);
		return false;
	}
}

/**
 * 检查权限状态
 * @param {String} scope 权限名称
 * @returns {Promise<Boolean>} 权限状态
 */
async function checkPermission(scope) {
	if (!scope) return false;
	
	// 确保scope包含前缀
	if (!scope.startsWith('scope.')) {
		scope = 'scope.' + scope;
	}
	
	return new Promise((resolve) => {
		wx.getSetting({
			success: (res) => {
				resolve(!!res.authSetting[scope]);
			},
			fail: () => {
				resolve(false);
			}
		});
	});
}

/**
 * 请求权限
 * @param {String} scope 权限名称
 * @param {String} explain 权限说明
 * @returns {Promise<Boolean>} 是否获得权限
 */
async function requestPermission(scope, explain) {
	if (!scope) return false;
	
	// 检查当前权限状态
	const hasPermission = await checkPermission(scope);
	if (hasPermission) return true;
	
	// 确保scope包含前缀
	if (!scope.startsWith('scope.')) {
		scope = 'scope.' + scope;
	}
	
	// 首次请求权限
	return new Promise((resolve) => {
		wx.authorize({
			scope,
			success: () => resolve(true),
			fail: () => {
				// 如果授权失败，提示用户在设置中开启
				if (explain) {
					wx.showModal({
						title: '权限请求',
						content: explain || `需要您授权${scope}权限才能继续使用`,
						confirmText: '去设置',
						success: (res) => {
							if (res.confirm) {
								wx.openSetting({
									success: (settingRes) => {
										resolve(!!settingRes.authSetting[scope]);
									},
									fail: () => resolve(false)
								});
							} else {
								resolve(false);
							}
						}
					});
				} else {
					resolve(false);
				}
			}
		});
	});
}

/**
 * 函数节流
 * @param {Function} fn 需要节流的函数
 * @param {Number} delay 延迟时间(ms)
 * @returns {Function} 节流后的函数
 */
function throttle(fn, delay = 500) {
	let timer = null;
	let lastTime = 0;
	
	return function(...args) {
		const context = this;
		const now = Date.now();
		
		if (now - lastTime >= delay) {
			fn.apply(context, args);
			lastTime = now;
		} else {
			clearTimeout(timer);
			timer = setTimeout(() => {
				fn.apply(context, args);
				lastTime = Date.now();
			}, delay);
		}
	};
}

/**
 * 安全调用API
 * @param {Function} apiFunc 要调用的API函数
 * @param {Object} options 选项
 * @returns {Promise} API调用结果
 */
function safeApiCall(apiFunc, options = {}) {
	return new Promise((resolve, reject) => {
		apiFunc({
			...options,
			success: (res) => resolve(res),
			fail: (err) => {
				console.error(`API调用失败: ${apiFunc.name || '未知API'}`, err);
				reject(err);
			}
		});
	});
}

/**
 * 获取胶囊按钮位置信息
 * @returns {Object} 胶囊按钮位置信息
 */
function getMenuButtonBoundingClientRect() {
	try {
		return wx.getMenuButtonBoundingClientRect();
	} catch (e) {
		console.error('获取胶囊按钮位置失败', e);
		return {};
	}
}

/**
 * 获取导航栏信息
 * @returns {Object} 导航栏信息
 */
function getNavigationBarInfo() {
	const systemInfo = getSystemInfo();
	const menuButtonInfo = getMenuButtonBoundingClientRect();
	
	if (!systemInfo || !menuButtonInfo) {
		return {
			navigationBarHeight: 44,
			statusBarHeight: 20,
			headerHeight: 64
		};
	}
	
	// 状态栏高度
	const statusBarHeight = systemInfo.statusBarHeight || 20;
	
	// 导航栏高度 = 胶囊底部坐标 - 状态栏高度 + 胶囊上下边距
	const navigationBarHeight = 
		(menuButtonInfo.bottom - statusBarHeight) + 
		(menuButtonInfo.top - statusBarHeight);
	
	// 整个头部高度 = 状态栏高度 + 导航栏高度
	const headerHeight = statusBarHeight + navigationBarHeight;
	
	return {
		navigationBarHeight,
		statusBarHeight,
		headerHeight,
		menuButtonInfo
	};
}

/**
 * 检查更新
 * 在小程序启动时调用，检查是否有可用更新
 */
function checkForUpdate() {
	if (typeof wx.getUpdateManager !== 'function') return;
	
	const updateManager = wx.getUpdateManager();
	
	updateManager.onCheckForUpdate((res) => {
		if (res.hasUpdate) {
			console.log('发现新版本');
		}
	});
	
	updateManager.onUpdateReady(() => {
		wx.showModal({
			title: '更新提示',
			content: '新版本已准备好，是否重启应用？',
			success: (res) => {
				if (res.confirm) {
					updateManager.applyUpdate();
				}
			}
		});
	});
	
	updateManager.onUpdateFailed(() => {
		console.error('新版本下载失败');
	});
}

// 导出所有工具函数
module.exports = {
	getAuth,
	buildShareOptions,
	normalizePath,
	buildFullUrl,
	safeNavigate,
	navigateTo,
	redirectTo,
	backToHome,
	getCurrentPagePath,
	getPrevPage,
	getSystemInfo,
	isIOS,
	isAndroid,
	isDev,
	getCurrentPage,
	getEnvironment,
	checkSDKVersion,
	checkPermission,
	requestPermission,
	throttle,
	safeApiCall,
	getMenuButtonBoundingClientRect,
	getNavigationBarInfo,
	checkForUpdate
}; 